const FULL_OPACITY = 255;
-function Button(text, button_color, pressed_button_color, min_width, min_height) {
- this._init(text, button_color, pressed_button_color, min_width, min_height);
+function Button(text, buttonColor, pressedButtonColor, minWidth, minHeight) {
+ this._init(text, buttonColor, pressedButtonColor, minWidth, minHeight);
}
Button.prototype = {
- _init : function(text, button_color, pressed_button_color, stays_pressed, min_width, min_height) {
+ _init : function(text, buttonColor, pressedButtonColor, staysPressed, minWidth, minHeight) {
- this._button_color = button_color
- if (button_color == null)
- this._button_color = DEFAULT_BUTTON_COLOR;
+ this._buttonColor = buttonColor
+ if (buttonColor == null)
+ this._buttonColor = DEFAULT_BUTTON_COLOR;
- this._pressed_button_color = pressed_button_color
- if (pressed_button_color == null)
- this._pressed_button_color = DEFAULT_PRESSED_BUTTON_COLOR;
+ this._pressedButtonColor = pressedButtonColor
+ if (pressedButtonColor == null)
+ this._pressedButtonColor = DEFAULT_PRESSED_BUTTON_COLOR;
- if (stays_pressed == null)
- stays_pressed = false
- if (min_width == null)
- min_width = 0;
- if (min_height == null)
- min_height = 0;
+ if (staysPressed == null)
+ staysPressed = false
+ if (minWidth == null)
+ minWidth = 0;
+ if (minHeight == null)
+ minHeight = 0;
- // if stays_pressed is true, this.active will be true past the first release of a button, untill a subsequent one (the button
+ // if staysPressed is true, this.active will be true past the first release of a button, untill a subsequent one (the button
// is unpressed) or untill release() is called explicitly
this._active = false;
- this._is_between_press_and_release = false;
- this._mouse_is_over_button = false;
+ this._isBetweenPressAndRelease = false;
+ this._mouseIsOverButton = false;
this.button = new Clutter.Group({reactive: true});
- this._background = new Clutter.Rectangle({ color: this._button_color});
- this._pressed_background = new Clutter.Rectangle({ color: this._pressed_button_color, opacity: NO_OPACITY});
+ this._background = new Clutter.Rectangle({ color: this._buttonColor});
+ this._pressedBackground = new Clutter.Rectangle({ color: this._pressedButtonColor, opacity: NO_OPACITY});
this._label = new Clutter.Label({ font_name: "Sans Bold 16px",
text: text});
this._label.set_position(5, 5);
- let background_width = Math.max(this._label.get_width()+10, min_width);
- let background_height = Math.max(this._label.get_height()+10, min_height);
- this._background.set_width(background_width)
- this._background.set_height(background_height)
- this._pressed_background.set_width(background_width)
- this._pressed_background.set_height(background_height)
+ let backgroundWidth = Math.max(this._label.get_width()+10, minWidth);
+ let backgroundHeight = Math.max(this._label.get_height()+10, minHeight);
+ this._background.set_width(backgroundWidth)
+ this._background.set_height(backgroundHeight)
+ this._pressedBackground.set_width(backgroundWidth)
+ this._pressedBackground.set_height(backgroundHeight)
this.button.add_actor(this._background);
- this.button.add_actor(this._pressed_background);
+ this.button.add_actor(this._pressedBackground);
this.button.add_actor(this._label);
let me = this;
this.button.connect('button-press-event',
function(o, event) {
- me._is_between_press_and_release = true;
- Tweener.addTween(me._pressed_background,
+ me._isBetweenPressAndRelease = true;
+ Tweener.addTween(me._pressedBackground,
{ time: ANIMATION_TIME,
opacity: FULL_OPACITY,
transition: "linear"
});
this.button.connect('button-release-event',
function(o, event) {
- me._is_between_press_and_release = false;
- if (!stays_pressed || me._active) {
+ me._isBetweenPressAndRelease = false;
+ if (!staysPressed || me._active) {
me.release();
} else {
me._active = true;
});
this.button.connect('enter-event',
function(o, event) {
- me._mouse_is_over_button = true;
+ me._mouseIsOverButton = true;
if (!me._active) {
- Tweener.removeTweens(me._pressed_background);
- me._pressed_background.set_opacity(PARTIAL_OPACITY);
+ Tweener.removeTweens(me._pressedBackground);
+ me._pressedBackground.set_opacity(PARTIAL_OPACITY);
}
return false;
});
this.button.connect('leave-event',
function(o, event) {
- me._is_between_press_and_release = false;
- me._mouse_is_over_button = false;
+ me._isBetweenPressAndRelease = false;
+ me._mouseIsOverButton = false;
if (!me._active) {
- Tweener.removeTweens(me._pressed_background);
- me._pressed_background.set_opacity(NO_OPACITY);
+ Tweener.removeTweens(me._pressedBackground);
+ me._pressedBackground.set_opacity(NO_OPACITY);
}
return false;
});
},
release : function() {
- if (!this._is_between_press_and_release) {
+ if (!this._isBetweenPressAndRelease) {
this._active = false;
- Tweener.removeTweens(this._pressed_background);
- if (this._mouse_is_over_button) {
- this._pressed_background.set_opacity(PARTIAL_OPACITY);
+ Tweener.removeTweens(this._pressedBackground);
+ if (this._mouseIsOverButton) {
+ this._pressedBackground.set_opacity(PARTIAL_OPACITY);
} else {
- this._pressed_background.set_opacity(NO_OPACITY);
+ this._pressedBackground.set_opacity(NO_OPACITY);
}
}
}
// counts we fall back to an algorithm. We need more schemes here
// unless we have a really good algorithm.
//
-// Each triplet is [x_center, y_center, scale] where the scale
+// Each triplet is [xCenter, yCenter, scale] where the scale
// is relative to the width of the desktop.
const POSITIONS = {
1: [[0.5, 0.5, 0.8]],
this._group.hide();
global.overlay_group.add_actor(this._group);
- this._window_clones = []
+ this._windowClones = []
},
show : function() {
let global = Shell.global_get();
let windows = global.get_windows();
- let desktop_window = null;
+ let desktopWindow = null;
- let screen_width = global.screen_width
- let screen_height = global.screen_height
+ let screenWidth = global.screen_width
+ let screenHeight = global.screen_height
for (let i = 0; i < windows.length; i++)
if (windows[i].get_window_type() == Meta.WindowType.DESKTOP)
- desktop_window = windows[i];
+ desktopWindow = windows[i];
// The desktop windows are shown on top of a scaled down version of the
// desktop. This is positioned at the right side of the screen
- this._desktop_width = screen_width * DESKTOP_SCALE;
- this._desktop_height = screen_height * DESKTOP_SCALE;
- this._desktop_x = screen_width - this._desktop_width - 10;
- this._desktop_y = Panel.PANEL_HEIGHT + (screen_height - this._desktop_height - Panel.PANEL_HEIGHT) / 2;
+ this._desktopWidth = screenWidth * DESKTOP_SCALE;
+ this._desktopHeight = screenHeight * DESKTOP_SCALE;
+ this._desktopX = screenWidth - this._desktopWidth - 10;
+ this._desktopY = Panel.PANEL_HEIGHT + (screenHeight - this._desktopHeight - Panel.PANEL_HEIGHT) / 2;
// If a file manager is displaying desktop icons, there will be a desktop window.
// This window will have the size of the whole desktop. When such window is not present
// (e.g. when the preference for showing icons on the desktop is disabled by the user
// or we are running inside a Xephyr window), we should create a desktop rectangle
// to serve as the background.
- if (desktop_window)
- this._createDesktopClone(desktop_window);
+ if (desktopWindow)
+ this._createDesktopClone(desktopWindow);
else
this._createDesktopRectangle();
// Count the total number of windows so we know what layout scheme to use
- let n_windows = 0;
+ let numberOfWindows = 0;
for (let i = 0; i < windows.length; i++) {
let w = windows[i];
- if (w == desktop_window || w.is_override_redirect())
+ if (w == desktopWindow || w.is_override_redirect())
continue;
- n_windows++;
+ numberOfWindows++;
}
// Now create actors for all the desktop windows. Do it in
// reverse order so that the active actor ends up on top
- let window_index = 0;
+ let windowIndex = 0;
for (let i = windows.length - 1; i >= 0; i--) {
let w = windows[i];
- if (w == desktop_window || w.is_override_redirect())
+ if (w == desktopWindow || w.is_override_redirect())
continue;
- this._createWindowClone(w, n_windows - window_index - 1, n_windows);
+ this._createWindowClone(w, numberOfWindows - windowIndex - 1, numberOfWindows);
- window_index++;
+ windowIndex++;
}
// All the the actors in the window group are completely obscured,
global.window_group.show()
this._group.hide();
- for (let i = 0; i < this._window_clones.length; i++) {
- this._window_clones[i].destroy();
+ for (let i = 0; i < this._windowClones.length; i++) {
+ this._windowClones[i].destroy();
}
- this._window_clones = [];
+ this._windowClones = [];
}
},
// up identically.
// We are also using (0,0) coordinates in both cases which makes the background
// window animate out from behind the panel.
- let desktop_rectangle = new Clutter.Rectangle({ color: global.stage.color,
+ let desktopRectangle = new Clutter.Rectangle({ color: global.stage.color,
reactive: true,
x: 0,
y: 0,
width: global.screen_width,
height: global.screen_height });
- this._addDesktop(desktop_rectangle);
+ this._addDesktop(desktopRectangle);
},
_addDesktop : function(desktop) {
- this._window_clones.push(desktop);
+ this._windowClones.push(desktop);
this._group.add_actor(desktop);
Tweener.addTween(desktop,
- { x: this._desktop_x,
- y: this._desktop_y,
+ { x: this._desktopX,
+ y: this._desktopY,
scale_x: DESKTOP_SCALE,
scale_y: DESKTOP_SCALE,
time: ANIMATION_TIME,
});
},
- // window_index == 0 => top in stacking order
- _computeWindowPosition : function(window_index, n_windows) {
- if (n_windows in POSITIONS)
- return POSITIONS[n_windows][window_index];
+ // windowIndex == 0 => top in stacking order
+ _computeWindowPosition : function(windowIndex, numberOfWindows) {
+ if (numberOfWindows in POSITIONS)
+ return POSITIONS[numberOfWindows][windowIndex];
// If we don't have a predefined scheme for this window count, overlap the windows
// along the diagonal of the desktop (improve this!)
- let fraction = Math.sqrt(1/n_windows);
+ let fraction = Math.sqrt(1/numberOfWindows);
// The top window goes at the lower right - this is different from the
// fixed position schemes where the windows are in "reading order"
// and the top window goes at the upper left.
- let pos = (n_windows - window_index - 1) / (n_windows - 1);
- let x_center = (fraction / 2) + (1 - fraction) * pos;
- let y_center = x_center;
+ let pos = (numberOfWindows - windowIndex - 1) / (numberOfWindows - 1);
+ let xCenter = (fraction / 2) + (1 - fraction) * pos;
+ let yCenter = xCenter;
- return [x_center, y_center, fraction];
+ return [xCenter, yCenter, fraction];
},
- _createWindowClone : function(w, window_index, n_windows) {
+ _createWindowClone : function(w, windowIndex, numberOfWindows) {
// We show the window using "clones" of the texture .. separate
// actors that mirror the original actors for the window. For
// animation purposes, it may be better to actually move the
x: w.x,
y: w.y });
- let [x_center, y_center, fraction] = this._computeWindowPosition(window_index, n_windows);
+ let [xCenter, yCenter, fraction] = this._computeWindowPosition(windowIndex, numberOfWindows);
- let desired_size = this._desktop_width * fraction;
+ let desiredSize = this._desktopWidth * fraction;
- x_center = this._desktop_x + x_center * this._desktop_width;
- y_center = this._desktop_y + y_center * this._desktop_height;
+ xCenter = this._desktopX + xCenter * this._desktopWidth;
+ yCenter = this._desktopY + yCenter * this._desktopHeight;
let size = clone.width;
if (clone.height > size)
size = clone.height;
// Never scale up
- let scale = desired_size / size;
+ let scale = desiredSize / size;
if (scale > 1)
scale = 1;
this._group.add_actor(clone);
- this._window_clones.push(clone);
+ this._windowClones.push(clone);
Tweener.addTween(clone,
- { x: x_center - 0.5 * scale * w.width,
- y: y_center - 0.5 * scale * w.height,
+ { x: xCenter - 0.5 * scale * w.width,
+ y: yCenter - 0.5 * scale * w.height,
scale_x: scale,
scale_y: scale,
time: ANIMATION_TIME,
projects / gnome-shell.git / commitdiff